package com.ljt.yupictureddd.domain.space.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ljt.yupictureddd.domain.space.entity.Space;
import com.ljt.yupictureddd.domain.space.entity.SpaceUser;
import com.ljt.yupictureddd.domain.space.service.SpaceDomainService;
import com.ljt.yupictureddd.domain.space.service.SpaceUserDomainService;
import com.ljt.yupictureddd.domain.space.valueobject.SpaceLevelEnums;
import com.ljt.yupictureddd.domain.space.valueobject.SpaceRoleEnums;
import com.ljt.yupictureddd.domain.space.valueobject.SpaceTypeEnums;
import com.ljt.yupictureddd.domain.user.entity.User;
import com.ljt.yupictureddd.domain.user.service.UserDomainService;
import com.ljt.yupictureddd.infrastracture.exception.ErrorCode;
import com.ljt.yupictureddd.infrastracture.exception.ThrowUtils;
import com.ljt.yupictureddd.infrastracture.mapper.SpaceMapper;
import com.ljt.yupictureddd.interfaces.dto.space.SpaceAddRequest;
import com.ljt.yupictureddd.interfaces.dto.space.SpaceQueryRequest;
import com.ljt.yupictureddd.interfaces.vo.space.SpaceVO;
import com.ljt.yupictureddd.interfaces.vo.user.UserVO;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 六件套
 * @description 针对表【space(空间)】的数据库操作Service实现
 * @createDate 2025-03-14 11:06:32
 */
@Service
public class SpaceDomainServiceImpl extends ServiceImpl<SpaceMapper, Space>
        implements SpaceDomainService {

    @Resource
    UserDomainService userDomainService;

    @Resource
    private TransactionTemplate transactionTemplate;

    @Resource
    private SpaceUserDomainService spaceUserDomainService;
    // @Autowired
    // @Lazy
    // 为了方便部署，不使用
    // private DynamicShardingManager dynamicShardingManager;

    /**
     * 创建空间
     *
     * @param request
     * @return
     */
    @Override
    public long createSpace(SpaceAddRequest request, User loginUser) {
        // 1.先校验参数
        ThrowUtils.throwIf(ObjUtil.isNull(request), ErrorCode.PARAMS_ERROR, "参数为空");
        Space space = BeanUtil.copyProperties(request, Space.class);
        if (StrUtil.isBlank(space.getSpaceName())) {
            space.setSpaceName("默认空间");
        }
        if (ObjUtil.isNull(space.getSpaceLevel())) {
            space.setSpaceLevel(SpaceLevelEnums.COMMON.getValue());
        }
        if (ObjUtil.isNull(space.getSpaceType())){
            space.setSpaceType(SpaceTypeEnums.PRIVATE.getValue());
        }
        // 2.校验权限 = > 无需
        // 3.校验存在 = > 非管理员只能创建普通级别的空间
        SpaceLevelEnums spaceLevelEnums = SpaceLevelEnums.getEnumByValue(space.getSpaceLevel());
        Long userId = loginUser.getId();
        ThrowUtils.throwIf(!loginUser.isAdmin() && space.getSpaceLevel() != SpaceLevelEnums.COMMON.getValue()
                , ErrorCode.NO_AUTH_ERROR, "非管理员只能创建普通级别的空间");

        // 补充参数 （只补充最大容量和最大数量）
        this.fillSpaceBySpaceLevel(space);
        space.setUserId(userId);
        // 校验参数
        this.validSpace(space, true);
        // 4.业务逻辑
        // 4.1同一个用户只能有一个私有空间 、以及一个团队空间
        // !!!锁➕事务（不要用Transactional注解）
        String lock = String.valueOf(userId).intern();
        synchronized (lock) {
            Long newId = transactionTemplate.execute((status) -> {
                // 查询用户是否存在一个私有空间了
                boolean exists = this.lambdaQuery()
                        .eq(Space::getUserId, userId)
                        // 一个用户只能创建一个类型的空间
                        .eq(Space::getSpaceType,space.getSpaceType())
                        .exists();
                // 已经存在，抛异常
                ThrowUtils.throwIf(exists, ErrorCode.NO_AUTH_ERROR, "一个用户只能有一个私有空间");
                // 5.操作数据库
                boolean save = this.save(space);
                ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR, "数据库插入私有空间失败");
                // 6.如果创建了团队空间，就要把自己加入这个空间。
                if (ObjUtil.equal(space.getSpaceType(),SpaceTypeEnums.TEAM.getValue())){
                    SpaceUser spaceUser = new SpaceUser();
                    spaceUser.setSpaceId(space.getId());
                    spaceUser.setUserId(space.getUserId());
                    spaceUser.setSpaceRole(SpaceRoleEnums.ADMIN.getValue());
                    spaceUser.setCreateTime(new Date());
                    spaceUser.setUpdateTime(new Date());
                    save = spaceUserDomainService.save(spaceUser);
                    ThrowUtils.throwIf(!save, ErrorCode.OPERATION_ERROR,"数据库插入团队空间成员失败");
                    // 7.如果创建了团队空间，别忘了创建团队空间表
                    // dynamicShardingManager.createSpacePictureTable(space);
                    // 为了方便部署，暂时不使用
                }
                return space.getId();
            });
            return Optional.ofNullable(newId).orElse(-1L);
        }
    }

    @Override
    public QueryWrapper<Space> getQueryWrapper(SpaceQueryRequest request) {
        ThrowUtils.throwIf(ObjUtil.isNull(request), ErrorCode.PARAMS_ERROR, "请求参数为空");

        Long id = request.getId();
        Long userId = request.getUserId();
        String spaceName = request.getSpaceName();
        Integer spaceLevel = request.getSpaceLevel();
        String sortField = request.getSortField();
        String sortOrder = request.getSortOrder();
        Integer spaceType = request.getSpaceType();


        QueryWrapper<Space> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(ObjUtil.isNotNull(id), "id", id);
        queryWrapper.like(StrUtil.isNotBlank(spaceName), "spaceName", spaceName);
        queryWrapper.eq(ObjUtil.isNotNull(spaceLevel), "spaceLevel", spaceLevel);
        queryWrapper.eq(ObjUtil.isNotNull(userId), "userId", userId);
        queryWrapper.eq(ObjUtil.isNotNull(spaceType),"spaceType",spaceType);

//        最后补充排序
        queryWrapper.orderBy(StrUtil.isNotEmpty(sortField), sortOrder.equals("ascend"), sortField);
        return queryWrapper;
    }

    @Override
    public SpaceVO getSpaceVO(Space space, HttpServletRequest request) {
        if (space == null) {
            return null;
        }
        SpaceVO spaceVO = SpaceVO.objToVo(space);
        Long userId = space.getUserId();
        if (userId != null && userId > 0) {
            User byId = userDomainService.getById(userId);
            UserVO userVO = userDomainService.getUserVO(byId);
            spaceVO.setUser(userVO);
        }
        return spaceVO;
    }

    @Override
    public Page<SpaceVO> getSpaceVOList(Page<Space> page, HttpServletRequest request) {
        Page<SpaceVO> spaceVOPage = new Page<>(page.getCurrent(), page.getSize(), page.getTotal());
        List<Space> spaceList = page.getRecords();
        if (CollUtil.isEmpty(spaceList)) {
            return spaceVOPage;
        }
//        对象列表 => 封装对象列表
        List<SpaceVO> spaceVOList = spaceList.stream().map(SpaceVO::objToVo).collect(Collectors.toList());
//        把所有的UserId收集起来,然后发一次数据库请求查出来,查一个整体,再用代码把数据库记录一条一条的塞回给SpaceVOList
        Set<Long> userIdSet = spaceList.stream().map(Space::getUserId).collect(Collectors.toSet());
        Map<Long, List<UserVO>> userVOListMap = userDomainService.listByIds(userIdSet).stream()
                .map(userDomainService::getUserVO)
                .collect(Collectors.groupingBy(UserVO::getId));// 这个map的泛型是因为用了groupingBy的原因,List都是只有一个元素的List
//        一条一条塞回去
        spaceVOList.forEach(p -> {
            Long userId = p.getUserId();
            if (userVOListMap.containsKey(userId)) {
                p.setUser((userVOListMap.get(userId).get(0)));
            }
        });
//        大功告成
        spaceVOPage.setRecords(spaceVOList);
        return spaceVOPage;
    }

    @Override
    public void validSpace(Space space, boolean add) {
        ThrowUtils.throwIf(space == null, ErrorCode.PARAMS_ERROR);

        Long id = space.getId();
        String spaceName = space.getSpaceName();
        Integer spaceLevel = space.getSpaceLevel();
        Integer spaceType = space.getSpaceType();
        SpaceTypeEnums spaceTypeEnums = SpaceTypeEnums.getEnumByValue(spaceType);
        // 创建的时候校验一下
        if (add) {
            ThrowUtils.throwIf(StrUtil.isBlank(spaceName), ErrorCode.PARAMS_ERROR, "空间名称为空");
            ThrowUtils.throwIf(ObjUtil.isNull(spaceLevel), ErrorCode.PARAMS_ERROR, "空间等级为空");
            ThrowUtils.throwIf(ObjUtil.isNull(SpaceLevelEnums.getEnumByValue(spaceLevel)), ErrorCode.PARAMS_ERROR, "空间等级不存在");
            ThrowUtils.throwIf(ObjUtil.isNull(spaceType), ErrorCode.PARAMS_ERROR, "空间类型为空");
            ThrowUtils.throwIf(ObjUtil.isNull(spaceTypeEnums), ErrorCode.PARAMS_ERROR, "空间类型不存在");
        }
        // 修改的时候,要对空间名称进行校验
        ThrowUtils.throwIf(StrUtil.isBlank(spaceName), ErrorCode.PARAMS_ERROR, "空间名称为空");
        ThrowUtils.throwIf(StrUtil.length(spaceName) > 30, ErrorCode.PARAMS_ERROR, "空间名称长度过长");
        // 修改时,对空间级别进行校验
        ThrowUtils.throwIf(ObjUtil.isNull(spaceLevel), ErrorCode.PARAMS_ERROR, "空间等级为空");
        ThrowUtils.throwIf(ObjUtil.isNull(SpaceLevelEnums.getEnumByValue(spaceLevel)), ErrorCode.PARAMS_ERROR, "空间等级不存在");
        // 修改时，对空间校验（万一）
        ThrowUtils.throwIf(ObjUtil.isNotNull(spaceType) && ObjUtil.isNull(spaceTypeEnums) , ErrorCode.PARAMS_ERROR,"空间类型不存在");
    }

    /**
     * 根据spacelevel空间等级来填充字段
     * @param space
     */
    @Override
    public void fillSpaceBySpaceLevel(Space space) {
        SpaceLevelEnums spaceLevelEnums = SpaceLevelEnums.getEnumByValue(space.getSpaceLevel());
        if (spaceLevelEnums!=null){
            long maxSize = spaceLevelEnums.getMaxSize();
            long maxCount = spaceLevelEnums.getMaxCount();
            if (space.getMaxSize() == null){
                space.setMaxSize(maxSize);
            }
            if (space.getMaxCount() ==null){
                space.setMaxCount(maxCount);
            }
        }
    }

}




